#include "c_lexer.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdarg.h>  // 添加对va_list的支持
#include <stdint.h>  // 添加对intptr_t的支持
#include "../common_defs.h"
#include "../vm/c_vm.h"

// 引用common_defs.h中定义的全局变量
extern char token_buffer[2048];  // 静态缓冲区存储当前token文本


// 声明全局初始化函数
extern void init_compiler_memory(int pool_size, const char* code);
/**
 * 初始化关键字和系统函数
 */
void init_keywords() {
    char *old_src_backup = old_src;
    char *src_backup = src;
    
    // 初始化作用域栈和全局作用域 - 添加这部分代码
    if (!scope_stack) {
        scope_stack = (ScopeStack*)malloc(sizeof(ScopeStack));
        scope_stack->top = 0;
        push_scope(scope_stack);  // 创建全局作用域
    }

    // 预定义关键字和系统函数字符串
    src = old_src = "char else enum if int return sizeof while for open read close printf malloc memset memcmp scanf free exit void main";
    
    // 1. 添加关键字到符号表, 这里非常重要这决定了在parser.c中能够正确识别关键字
    int i = Char;
    while (i <= For) {
        next();
        current_id[Token] = i++; // 关键字的特殊Token类型值，唯一标识关键字
    }
    
    // 2. 添加库函数到符号表
    // 系统函数对应虚拟机指令集中的值
    i = OPEN;
    while (i <= EXIT) {
        next();
        current_id[Class] = Sys;
        current_id[Type] = INT;
        current_id[Value] = i++;
        
        // 如果新符号表的全局作用域已初始化，同步添加系统函数
        if (scope_stack && scope_stack->top > 0) {
            // 获取全局作用域
            Scope* global_scope = current_scope(scope_stack);
            if (global_scope) {
                // 创建系统函数的符号信息
                SymInfo* sys_info = (SymInfo*)malloc(sizeof(SymInfo));
                memset(sys_info, 0, sizeof(SymInfo));
                
                // 设置系统函数信息
                sys_info->name = strdup((const char*)current_id[Name]);
                sys_info->data_type = TYPE_INT;  // 返回值类型设置为INT
                sys_info->sym_class = SYM_SYSTEM; // 设置为系统函数
                sys_info->addr = current_id[Value]; // 地址设置为对应枚举值
                sys_info->scope = global_scope;     // 设置所属作用域
                
                // 添加到全局作用域
                add_symbol(global_scope, sys_info->name, sys_info);
            }
        }
    }
    
    // 处理void类型和main函数
    next(); 
    current_id[Token] = Char;  // 将void视为Char类型
    
    
    // 恢复原来的源代码指针
    old_src = old_src_backup;
    src = src_backup;

    line = 1;
    column = 1;  // 重置列号
    token = 0;
    token_val = 0;
    memset(token_buffer, 0, sizeof(token_buffer));
    
}


// 获取TokenType的字符串表示
static const char* get_token_type_string(TokenType type) {
    switch (type) {
        case Num: return "NUMBER";
        case Str: return "STRING";
        case Fun: return "FUNCTION";
        case Sys: return "SYSTEM";
        case Glo: return "GLOBAL";
        case Loc: return "LOCAL";
        case Id: return "IDENTIFIER";
        case Char: return "CHAR";
        case Else: return "ELSE";
        case Enum: return "ENUM";
        case If: return "IF";
        case Int: return "INT";
        case Return: return "RETURN";
        case Sizeof: return "SIZEOF";
        case While: return "WHILE";
        case For: return "FOR";
        case Assign: return "ASSIGN";
        case Cond: return "COND";
        case Lor: return "LOR";
        case Lan: return "LAN";
        case Or: return "OR";
        case Xor: return "XOR";
        case And: return "AND";
        case Eq: return "EQ";
        case Ne: return "NE";
        case Lt: return "LT";
        case Gt: return "GT";
        case Le: return "LE";
        case Ge: return "GE";
        case Shl: return "SHL";
        case Shr: return "SHR";
        case Add: return "ADD";
        case Sub: return "SUB";
        case Mul: return "MUL";
        case Div: return "DIV";
        case Mod: return "MOD";
        case Inc: return "INC";
        case Dec: return "DEC";
        case Brak: return "BRAK";
        default: return "UNKNOWN";
    }
}


// 初始化词法分析器
void init_lexer(const char* code) {
    init_compiler_memory(1 * 1024 * 1024, code); // 初始化内存分配
    
    init_keywords(); // 初始化关键字和系统函数
}

// 读取下一个token
void next() {
    char *last_pos;
    int token_start_column = column;  // 记录token开始的列号

    // 跳过空白字符
    while (src && *src && (token = *src)) {
        ++src;
        ++column;  // 更新列号

        // 处理换行
        if (token == '\n') {
            ++line;
            column = 1;  // 重置列号到行首
        }
        // 处理预处理指令
        else if (token == '#') {
            // 跳过预处理指令，我们不支持它
            while (*src != 0 && *src != '\n') {
                src++;
                column++;  // 更新列号
            }
        }
        // 处理标识符和关键字
        else if ((token >= 'a' && token <= 'z') || (token >= 'A' && token <= 'Z') || (token == '_')) {
            // 解析标识符
            last_pos = src - 1;
            
            // 记录标识符开始位置
            char* id_start = last_pos;
            
            // 移动到标识符结束位置
            while ((*src >= 'a' && *src <= 'z') || (*src >= 'A' && *src <= 'Z') || 
                   (*src >= '0' && *src <= '9') || (*src == '_')) {
                src++;
                column++;  // 更新列号
            }

            // 计算标识符长度
            int len = src - last_pos;
            
            // 为了保存原始token文本用于显示
            if (len < sizeof(token_buffer) - 1) {
                strncpy(token_buffer, last_pos, len);
                token_buffer[len] = '\0';
            } else {
                strncpy(token_buffer, last_pos, sizeof(token_buffer) - 1);
                token_buffer[sizeof(token_buffer) - 1] = '\0';
            }
            
            // 使用统一的哈希函数计算哈希值
            unsigned int hash = hash_string(token_buffer);

            // 现在老符号表的作用只用于查找现有关键字和系统函数，自定义函数的标识符的token类型，除了关键字有特殊token外，函数和变量的token都为Id.标识符的作用域和符号表的判断在parser.c中由新符号表进行查找和判断。为什么不使用新符号表代替这部分查找？因为系统函数和关键字的作用域是全局，而变量和自定义函数的作用域在当前作用域。查找的话也需要分为两部分查找，第一在当前作用域查找，之后到全局作用域查找。其次，由于关键字不是符号的一种，所以也没有加入新符号表。
            current_id = (intptr_t*)symbols;
            while (current_id[Token]) {
                if (current_id[Hash] == hash && 
                    !memcmp((char *)current_id[Name], last_pos, src - last_pos)) {// 等于是哈希表通过key查找value，key为Name，value为token。memcmp是比较内存中的内容是否相等，不是比较内存地址
                    // 找到了，返回对应的token
                    token = current_id[Token];
                    //printf("sysmbols find\n");
                    return;
                }
                current_id = (intptr_t*)((intptr_t*)current_id + IdSize);
            }

            // 将标识符存入data区
            char *data_ptr = vm_get_data();
            char *id_data_ptr = data_ptr;
            
            // 复制标识符到data区
            memcpy(data_ptr, last_pos, len);
            data_ptr += len;
            
            // 添加字符串终止符
            *data_ptr++ = '\0';
            
            // 对齐到64字节
            data_ptr = (char *)(((intptr_t)data_ptr + 64) & (-64));
            
            // 更新data段指针
            vm_set_data(data_ptr);

            // 存储新的标识符，指向data区而不是源代码
            current_id[Name] = (intptr_t)id_data_ptr;  // 标识符的起始位置指向data区
            current_id[Hash] = hash;
            token = current_id[Token] = Id;  // 默认为标识符类型
            
            return;
        }
        // 处理数字
        else if (token >= '0' && token <= '9') {
            // 解析数字，三种类型：十进制(123)，十六进制(0x123)，八进制(017)
            token_val = token - '0';
            if (token_val > 0) {
                // 十进制，以[1-9]开头
                int i = 0;
                token_buffer[i++] = token;
                
                while (*src >= '0' && *src <= '9') {
                    if (i < sizeof(token_buffer) - 1) {
                        token_buffer[i++] = *src;
                    }
                    token_val = token_val * 10 + *src++ - '0';
                    column++;  // 更新列号
                }
                token_buffer[i] = '\0';
            } else {
                // 以0开头
                token_buffer[0] = '0';
                int i = 1;
                
                if (*src == 'x' || *src == 'X') {
                    // 十六进制
                    token_buffer[i++] = *src;
                    token = *++src;
                    column += 2;  // 更新列号 (0x)
                    while ((token >= '0' && token <= '9') || 
                           (token >= 'a' && token <= 'f') || 
                           (token >= 'A' && token <= 'F')) {
                        if (i < sizeof(token_buffer) - 1) {
                            token_buffer[i++] = token;
                        }
                        token_val = token_val * 16 + (token & 15) + (token >= 'A' ? 9 : 0);
                        token = *++src;
                        column++;  // 更新列号
                    }
                } else {
                    // 八进制
                    while (*src >= '0' && *src <= '7') {
                        if (i < sizeof(token_buffer) - 1) {
                            token_buffer[i++] = *src;
                        }
                        token_val = token_val * 8 + *src++ - '0';
                        column++;  // 更新列号
                    }
                }
                token_buffer[i] = '\0';
            }

            token = Num;
            return;
        }
        // 处理字符串和字符常量
        else if (token == '"' || token == '\'') {
            // 解析字符串或字符字面量
            char *data_ptr = vm_get_data(); // 获取data段当前位置
            
            last_pos = data_ptr; // 保存字符串起始位置
            
            // 为显示目的保存起始引号
            token_buffer[0] = token;
            int i = 1;
            
            while (*src != 0 && *src != token) { // token== *src说明匹配到字符串结束"
                token_val = *src++;
                column++;  // 更新列号
                if (token_val == '\\') { // 这一个判断是处理字符串中的转义字符\n或单字符'\n'，保证存入data段的字符串是存入的\n转义字符，而不是\和n两个字符
                    // 处理转义字符
                    if (i < sizeof(token_buffer) - 2) {
                        token_buffer[i++] = '\\';
                    }
                    
                    token_val = *src++;
                    column++;  // 更新列号
                    if (token_val == 'n') {
                        if (i < sizeof(token_buffer) - 2) {
                            token_buffer[i++] = 'n';
                        }
                        token_val = '\n';
                    } else if (i < sizeof(token_buffer) - 2) { // 因为需要保存最后的"或'以及\0所以需要预留2个位置
                        token_buffer[i++] = token_val;
                    }
                } else if (i < sizeof(token_buffer) - 2) {
                    token_buffer[i++] = token_val;
                }
                
                if (token == '"') {
                    // 判断当前解析的是字符串字面量存入data段
                    *data_ptr++ = token_val;
                }
            }
            
            // 保存结束引号
            if (i < sizeof(token_buffer) - 1) {
                token_buffer[i++] = token;
                token_buffer[i] = '\0';
            } else { // 如果token_buffer满了，则强制截断
                token_buffer[sizeof(token_buffer) - 2] = token;
                token_buffer[sizeof(token_buffer) - 1] = '\0';
            }
            
            src++; // 跳过结束引号
            column++;  // 更新列号
            
            // 处理结果
            if (token == '"') {
                // 字符串常量存储在data区时末尾添加null终止符
                *data_ptr++ = '\0';
                
                // 使用位操作将data_ptr对齐到64字节
                data_ptr = (char *)(((intptr_t)data_ptr + 64) & (-64));
                
                // 更新data段指针，以便后续使用
                vm_set_data(data_ptr);
                
                token_val = (intptr_t)last_pos; // 保存指向data段的起始位置指针
                token = Str;
            } else {
                // 对于字符常量，作为数字处理
                token = Num;
            }
            
            return;
        }
        // 处理注释
        else if (token == '/') {
            if (*src == '/') {
                // 处理行注释 //
                ++src;
                ++column;  // 更新列号
                while (*src != 0 && *src != '\n') {
                    ++src;
                    ++column;  // 更新列号
                }
            } else if (*src == '*') {
                // 处理块注释 /* ... */
                ++src;
                ++column;  // 更新列号
                while (*src && !(*src == '*' && *(src+1) == '/')) {
                    if (*src == '\n') {
                        line++;
                        column = 1;  // 重置列号到行首
                    } else {
                        column++;  // 更新列号
                    }
                    ++src;
                }
                if (*src) { // 跳过结束注释*/
                    src += 2;
                    column += 2;  // 更新列号
                }
            } else {
                // 除法运算符
                token = Div;
                token_buffer[0] = '/';
                token_buffer[1] = '\0';
                return;
            }
        }
        // 处理其他运算符和标点符号
        else if (token == '=') {
            if (*src == '=') { 
                src++; 
                token = Eq; 
                strcpy(token_buffer, "==");
            }
            else {
                token = Assign;
                token_buffer[0] = '=';
                token_buffer[1] = '\0';
            }
            return;
        }
        else if (token == '+') {
            if (*src == '+') { 
                src++; 
                token = Inc; 
                strcpy(token_buffer, "++");
            }
            else {
                token = Add;
                token_buffer[0] = '+';
                token_buffer[1] = '\0';
            }
            return;
        }
        else if (token == '-') {
            if (*src == '-') { 
                src++; 
                token = Dec;
                strcpy(token_buffer, "--");
            }
            else {
                token = Sub;
                token_buffer[0] = '-';
                token_buffer[1] = '\0';
            }
            return;
        }
        else if (token == '!') {
            if (*src == '=') { 
                src++; 
                token = Ne;
                strcpy(token_buffer, "!=");
            }
            else {
                token_buffer[0] = '!';
                token_buffer[1] = '\0';
            }
            return;
        }
        else if (token == '<') {
            if (*src == '=') { 
                src++; 
                token = Le;
                strcpy(token_buffer, "<=");
            }
            else if (*src == '<') { 
                src++; 
                token = Shl;
                strcpy(token_buffer, "<<");
            }
            else {
                token = Lt;
                token_buffer[0] = '<';
                token_buffer[1] = '\0';
            }
            return;
        }
        else if (token == '>') {
            if (*src == '=') { 
                src++; 
                token = Ge;
                strcpy(token_buffer, ">=");
            }
            else if (*src == '>') { 
                src++; 
                token = Shr;
                strcpy(token_buffer, ">>");
            }
            else {
                token = Gt;
                token_buffer[0] = '>';
                token_buffer[1] = '\0';
            }
            return;
        }
        else if (token == '|') {
            if (*src == '|') { 
                src++; 
                token = Lor;
                strcpy(token_buffer, "||");
            }
            else {
                token = Or;
                token_buffer[0] = '|';
                token_buffer[1] = '\0';
            }
            return;
        }
        else if (token == '&') {
            if (*src == '&') { 
                src++; 
                token = Lan;
                strcpy(token_buffer, "&&");
            }
            else {
                token = And;
                token_buffer[0] = '&';
                token_buffer[1] = '\0';
            }
            return;
        }
        else if (token == '^') { 
            token = Xor;
            token_buffer[0] = '^';
            token_buffer[1] = '\0';
            return;
        }
        else if (token == '%') { 
            token = Mod;
            token_buffer[0] = '%';
            token_buffer[1] = '\0';
            return;
        }
        else if (token == '*') { 
            token = Mul;
            token_buffer[0] = '*';
            token_buffer[1] = '\0';
            return;
        }
        else if (token == '[') { 
            token = Brak;
            token_buffer[0] = '[';
            token_buffer[1] = '\0';
            return;
        }
        else if (token == '?') { 
            token = Cond;
            token_buffer[0] = '?';
            token_buffer[1] = '\0';
            return;
        }
        else if (token == '~' || token == ';' || token == '{' || token == '}' || 
                 token == '(' || token == ')' || token == ']' || token == ',' || token == ':') {
            // 直接返回字符作为token
            token_buffer[0] = token;
            token_buffer[1] = '\0';
            return;
        }
        // 如果到这里，表示当前字符无法识别或者是空白字符，继续读取下一个
    }
    
    // 设置为文件结束标记
    token = 0;
    token_buffer[0] = '\0';
    return;
}

// 匹配当前token
void match(int tk) {
    if (token == tk) {
        next();
    } else {
        printf("%d: expected token: %d\n", line, tk);
        exit(-1);
    }
}

// 创建一个新的Token
static ShowToken create_token(TokenType type, const char* text, int line, int column) {
    ShowToken token;
    token.type = type;
    // 使用静态分配的缓冲区复制字符串，避免内存泄漏
    token.text = strdup(text ? text : "");
    token.line = line;
    token.column = column;
    token.value = token_val;
    token.hash = 0;
    return token;
}

// 添加词法错误
static void add_lex_error(LexResult* result, LexErrorType type, int line, int column, const char* format, ...) {
    // 扩展错误数组
    if (result->error_count == 0) {
        result->errors = (LexError*)malloc(sizeof(LexError) * 8);  // 初始分配8个错误空间
    } else if (result->error_count % 8 == 0) {
        // 每8个错误扩容一次
        result->errors = (LexError*)realloc(result->errors, sizeof(LexError) * (result->error_count + 8));
    }
    
    if (!result->errors) {
        // 内存分配失败
        return;
    }
    
    // 格式化错误信息
    va_list args;
    va_start(args, format);
    char message[256] = {0};
    vsnprintf(message, sizeof(message) - 1, format, args);
    va_end(args);
    
    // 添加错误
    result->errors[result->error_count].type = type;
    result->errors[result->error_count].line = line;
    result->errors[result->error_count].column = column;
    result->errors[result->error_count].message = strdup(message);
    result->error_count++;
}

// 检查标识符合法性
static void check_identifier(LexResult* result, const ShowToken* token) {
    const char* text = token->text;
    
    // 检查是否为关键字
    if (token->type >= Char && token->type <= While) {
        return;  // 关键字不做进一步检查
    }
    
    // 检查首字符
    if (text && text[0] && !(isalpha(text[0]) || text[0] == '_')) {
        add_lex_error(result, ERR_ILLEGAL_IDENTIFIER, token->line, token->column,
                     "非法标识符：'%s'，标识符必须以字母或下划线开头", text);
        return;
    }
    
    // 检查其余字符
    for (int i = 1; text && text[i]; i++) {
        if (!(isalnum(text[i]) || text[i] == '_')) {
            add_lex_error(result, ERR_ILLEGAL_IDENTIFIER, token->line, token->column,
                         "非法标识符：'%s'，标识符只能包含字母、数字和下划线", text);
            return;
        }
    }
}

// 检查数值常量错误
static void check_numeric_errors(const char* code, LexResult* result) {
    const char* ptr = code;
    int line = 1;
    int column = 1;
    
    while (*ptr) {
        // 跳过空白字符
        if (isspace(*ptr)) {
            if (*ptr == '\n') {
                line++;
                column = 1;
            } else {
                column++;
            }
            ptr++;
            continue;
        }
        
        // 定义解析状态
        enum {
            STATE_NORMAL,
            STATE_HEX,
            STATE_FLOAT,
            STATE_OCTAL,
            STATE_CHECK_SUFFIX
        } state = STATE_NORMAL;
        
        // 检查数字
        if (isdigit(*ptr)) {
            const char* start = ptr;
            int start_col = column;
            state = STATE_NORMAL;

            // 确定初始状态
            if (*ptr == '0') {
                if (*(ptr + 1) == 'x' || *(ptr + 1) == 'X') {
                    // 十六进制数
                    ptr += 2;
                    column += 2;
                    state = STATE_HEX;
                } else if (isdigit(*(ptr + 1))) {
                    // 八进制数
                    ptr++;
                    column++;
                    state = STATE_OCTAL;
                } else if (*(ptr + 1) == '.') {
                    // 浮点数 0.x
                    ptr++;
                    column++;
                    state = STATE_FLOAT;
                } else {
                    // 单个0
                    ptr++;
                    column++;
                    state = STATE_CHECK_SUFFIX;
                }
            } else {
                // 其他数字开头（1-9）
                while (isdigit(*ptr)) {
                    ptr++;
                    column++;
                }
                
                if (*ptr == '.') {
                    state = STATE_FLOAT;
                } else {
                    state = STATE_CHECK_SUFFIX;
                }
            }
            
            // 使用switch处理不同的解析状态
            switch (state) {
                case STATE_HEX:
                    // 检查十六进制数
                    if (!*ptr || !isxdigit(*ptr)) {
                        add_lex_error(result, ERR_HEX_NUMBER, line, start_col,
                                    "非法的十六进制数: 缺少十六进制数字");
                        break;
                    }
                    
                    while (isxdigit(*ptr)) {
                        ptr++;
                        column++;
                    }
                    
                    if (isalnum(*ptr)) {
                        add_lex_error(result, ERR_HEX_NUMBER, line, start_col,
                                    "非法的十六进制数: 包含非法字符 '%c'", *ptr);
                    }
                    break;
                    
                case STATE_OCTAL:
                    // 检查八进制数
                    {
                        int is_valid_octal = 1;
                        
                        while (isdigit(*ptr)) {
                            if (*ptr > '7') {
                                is_valid_octal = 0;
                                add_lex_error(result, ERR_OCTAL_NUMBER, line, start_col,
                                            "非法的八进制数: 包含数字 '%c'", *ptr);
                                break;
                            }
                            ptr++;
                            column++;
                        }
                        
                        if (*ptr == '.') {
                            add_lex_error(result, ERR_DECIMAL_NUMBER, line, start_col,
                                        "非法的数字格式: 不支持8进制浮点数");
                            state = STATE_FLOAT;
                        } else {
                            if (!is_valid_octal) {
                                // 跳过剩余的非法八进制部分
                                while (isdigit(*ptr)) {
                                    ptr++;
                                    column++;
                                }
                            }
                            state = STATE_CHECK_SUFFIX;
                            continue;
                        }
                    }
                    // 如果是浮点数，落入FLOAT处理
                    
                case STATE_FLOAT:
                    // 处理小数部分
                    if (*ptr == '.') {
                        ptr++;
                        column++;
                        
                        // 小数点后的数字
                        while (isdigit(*ptr)) {
                            ptr++;
                            column++;
                        }
                        
                        // 检查多个小数点
                        if (*ptr == '.') {
                            add_lex_error(result, ERR_FLOAT_NUMBER, line, start_col,
                                        "非法的浮点数: 多个小数点");
                            // 跳过其余的数字和小数点
                            while (isdigit(*ptr) || *ptr == '.') {
                                ptr++;
                                column++;
                            }
                        }
                    }
                    state = STATE_CHECK_SUFFIX;
                    // 处理后缀，不需要break，直接落入CHECK_SUFFIX处理
                    
                case STATE_CHECK_SUFFIX:
                    // 指数部分 (e或E)
                    if (*ptr == 'e' || *ptr == 'E') {
                        ptr++;
                        column++;
                        
                        // 可选的符号
                        if (*ptr == '+' || *ptr == '-') {
                            ptr++;
                            column++;
                        }
                        
                        // 指数部分必须有数字
                        if (!isdigit(*ptr)) {
                            add_lex_error(result, ERR_FLOAT_NUMBER, line, start_col,
                                        "非法的浮点数: 指数部分缺少数字");
                        } else {
                            // 读取指数数字
                            while (isdigit(*ptr)) {
                                ptr++;
                                column++;
                            }
                        }
                    }
                    
                    // 检查数字后面是否有非法字符
                    if (isalpha(*ptr) && *ptr != 'f' && *ptr != 'F' && *ptr != 'l' && *ptr != 'L' && 
                        *ptr != 'u' && *ptr != 'U') {
                        add_lex_error(result, ERR_DECIMAL_NUMBER, line, start_col,
                                    "非法的数字: 包含非法字符 '%c'", *ptr);
                        // 跳过非法字符
                        while (isalnum(*ptr)) {
                            ptr++;
                            column++;
                        }
                    }
                    break;
                    
                default:
                    // STATE_NORMAL和其他状态
                    break;
            }
            
            continue;
        }
        
        ptr++;
        column++;
    }
}

// 检查字符和字符串常量错误
static void check_char_string_errors(const char* code, LexResult* result) {
    const char* ptr = code;
    int line = 1;
    int column = 1;
    
    while (*ptr) {
        // 检查字符常量
        if (*ptr == '\'') {
            const char* start = ptr;
            int start_col = column;
            ptr++;
            column++;
            
            // 检查空字符常量
            if (*ptr == '\'') {
                add_lex_error(result, ERR_CHAR_CONST, line, start_col,
                            "空的字符常量");
                ptr++;
                column++;
                continue;
            }
            
            // 处理转义字符
            if (*ptr == '\\') {
                ptr++;
                column++;
                if (!*ptr) {
                    add_lex_error(result, ERR_CHAR_CONST, line, start_col,
                                "未闭合的字符常量: 转义序列不完整");
                    break;
                }
                ptr++;
                column++;
            } else if (*ptr) {
                ptr++;
                column++;
            }
            
            // 检查字符常量的闭合
            if (*ptr != '\'') {
                add_lex_error(result, ERR_CHAR_CONST, line, start_col,
                            "未闭合的字符常量");
                continue;
            }
            
            ptr++;
            column++;
            continue;
        }
        
        // 检查字符串常量
        if (*ptr == '"') {
            const char* start = ptr;
            int start_col = column;
            ptr++;
            column++;
            
            while (*ptr && *ptr != '"') {
                if (*ptr == '\\') {
                    ptr++;
                    column++;
                    if (!*ptr) {
                        add_lex_error(result, ERR_STRING_CONST, line, start_col,
                                    "未闭合的字符串: 转义序列不完整");
                        break;
                    }
                }
                if (*ptr == '\n') {
                    add_lex_error(result, ERR_STRING_CONST, line, start_col,
                                "字符串不能跨行");
                    break;
                }
                ptr++;
                column++;
            }
            
            if (!*ptr) {
                add_lex_error(result, ERR_STRING_CONST, line, start_col,
                            "未闭合的字符串");
                break;
            }
            
            ptr++;
            column++;
            continue;
        }
        
        if (*ptr == '\n') {
            line++;
            column = 1;
        } else {
            column++;
        }
        ptr++;
    }
}

// 检查注释错误
static void check_comment_errors(const char* code, LexResult* result) {
    const char* ptr = code;
    int line = 1;
    int column = 1;
    
    while (*ptr) {
        // 检查注释
        if (*ptr == '/' && *(ptr + 1) == '*') {
            const char* start = ptr;
            int start_col = column;
            ptr += 2;
            column += 2;
            
            int found_end = 0;
            while (*ptr) {
                if (*ptr == '*' && *(ptr + 1) == '/') {
                    found_end = 1;
                    ptr += 2;
                    column += 2;
                    break;
                }
                
                if (*ptr == '\n') {
                    line++;
                    column = 1;
                } else {
                    column++;
                }
                ptr++;
            }
            
            if (!found_end) {
                add_lex_error(result, ERR_COMMENT, line, start_col,
                            "未闭合的注释");
            }
            continue;
        }
        
        if (*ptr == '\n') {
            line++;
            column = 1;
        } else {
            column++;
        }
        ptr++;
    }
}

// 检查非法字符错误
static void check_invalid_char_errors(const char* code, LexResult* result) {
    const char* ptr = code;
    int line = 1;
    int column = 1;
    
    while (*ptr) {
        // 检查非法字符
        if (*ptr == '@' || *ptr == '`' || *ptr == '$') {
            add_lex_error(result, ERR_INVALID_CHAR, line, column,
                        "非法字符: '%c'", *ptr);
        }
        
        if (*ptr == '\n') {
            line++;
            column = 1;
        } else {
            column++;
        }
        ptr++;
    }
}

// 检查预处理指令错误
static void check_preprocessor_errors(const char* code, LexResult* result) {
    const char* ptr = code;
    int line = 1;
    int column = 1;
    
    while (*ptr) {
        if (*ptr == '#') {
            const char* start = ptr;
            int start_col = column;
            ptr++;
            column++;
            
            // 跳过空白字符
            while (*ptr && isspace(*ptr) && *ptr != '\n') {
                ptr++;
                column++;
            }
            
            // 读取预处理指令
            char directive[32] = {0};
            int i = 0;
            while (*ptr && !isspace(*ptr) && i < sizeof(directive) - 1) {
                directive[i++] = *ptr;
                ptr++;
                column++;
            }
            
            // 检查include指令
            if (strcmp(directive, "include") == 0) {
                // 跳过空白字符
                while (*ptr && isspace(*ptr) && *ptr != '\n') {
                    ptr++;
                    column++;
                }
                
                if (!*ptr || (*ptr != '<' && *ptr != '"')) {
                    add_lex_error(result, ERR_PREPROCESSOR, line, start_col,
                                "include指令缺少文件名");
                }
            }
        }
        
        if (*ptr == '\n') {
            line++;
            column = 1;
        } else {
            column++;
        }
        ptr++;
    }
}

// 检查运算符错误
static void check_operator_errors(const char* code, LexResult* result) {
    const char* ptr = code;
    int line = 1;
    int column = 1;
    
    // 有效的C语言运算符列表
    const char* valid_operators[] = {
        // 算术运算符
        "+", "-", "*", "/", "%", "++", "--",
        // 关系运算符
        "==", "!=", ">", "<", ">=", "<=",
        // 逻辑运算符
        "&&", "||", "!",
        // 位运算符
        "&", "|", "^", "~", "<<", ">>",
        // 赋值运算符
        "=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", "&=", "|=", "^=",
        // 其他运算符
        ".", "->", "?", ":"
    };
    int num_valid_operators = sizeof(valid_operators) / sizeof(valid_operators[0]);
    
    while (*ptr) {
        // 跳过空白字符和字符串/字符常量
        if (isspace(*ptr)) {
            if (*ptr == '\n') {
                line++;
                column = 1;
            } else {
                column++;
            }
            ptr++;
            continue;
        }
        
        // 跳过注释
        if (*ptr == '/' && *(ptr + 1) == '/') {
            // 行注释
            ptr += 2;
            column += 2;
            while (*ptr && *ptr != '\n') {
                ptr++;
                column++;
            }
            continue;
        }
        if (*ptr == '/' && *(ptr + 1) == '*') {
            // 块注释
            ptr += 2;
            column += 2;
            while (*ptr && !(*ptr == '*' && *(ptr + 1) == '/')) {
                if (*ptr == '\n') {
                    line++;
                    column = 1;
                } else {
                    column++;
                }
                ptr++;
            }
            if (*ptr) { // 跳过结束注释*/
                ptr += 2;
                column += 2;
            }
            continue;
        }
        
        // 跳过字符串
        if (*ptr == '"') {
            ptr++;
            column++;
            while (*ptr && *ptr != '"') {
                if (*ptr == '\\') {
                    ptr++;
                    column++;
                    if (*ptr) {
                        ptr++;
                        column++;
                    }
                } else {
                    if (*ptr == '\n') {
                        line++;
                        column = 1;
                    } else {
                        column++;
                    }
                    ptr++;
                }
            }
            if (*ptr) {
                ptr++;
                column++;
            }
            continue;
        }
        
        // 跳过字符常量
        if (*ptr == '\'') {
            ptr++;
            column++;
            while (*ptr && *ptr != '\'') {
                if (*ptr == '\\') {
                    ptr++;
                    column++;
                    if (*ptr) {
                        ptr++;
                        column++;
                    }
                } else {
                    column++;
                    ptr++;
                }
            }
            if (*ptr) {
                ptr++;
                column++;
            }
            continue;
        }
        
        // 检查可能的运算符
        if (strchr("+-*/%=<>!&|^~?:.", *ptr)) {
            const char* op_start = ptr;
            int op_start_col = column;
            char operator[4] = {0}; // 足够存储3字符运算符+'\0'
            int op_len = 0;
            
            // 读取可能的运算符
            while (op_len < 3 && strchr("+-*/%=<>!&|^~?:.", *ptr)) {
                operator[op_len++] = *ptr;
                ptr++;
                column++;
            }
            operator[op_len] = '\0';
            
            // 检查是否为有效运算符
            int is_valid = 0;
            for (int i = 0; i < num_valid_operators; i++) {
                if (strcmp(operator, valid_operators[i]) == 0) {
                    is_valid = 1;
                    break;
                }
            }
            
            // 检查特殊情况：===（JavaScript严格相等）
            if (strcmp(operator, "===") == 0) {
                add_lex_error(result, ERR_ILLEGAL_OPERATOR, line, op_start_col,
                            "非法运算符 '===': C语言中使用 '==' 进行相等比较");
                continue;
            }
            
            // 检查特殊情况：!==（JavaScript严格不等）
            if (strcmp(operator, "!==") == 0) {
                add_lex_error(result, ERR_ILLEGAL_OPERATOR, line, op_start_col,
                            "非法运算符 '!==': C语言中使用 '!=' 进行不等比较");
                continue;
            }
            
            // 检查特殊情况：**（指数运算）
            if (strcmp(operator, "**") == 0) {
                add_lex_error(result, ERR_ILLEGAL_OPERATOR, line, op_start_col,
                            "非法运算符 '**': C语言不支持指数运算符，请使用pow()函数");
                continue;
            }
            
            // 检查<>（不等于的错误写法）
            if (strcmp(operator, "<>") == 0) {
                add_lex_error(result, ERR_ILLEGAL_OPERATOR, line, op_start_col,
                            "非法运算符 '<>': C语言中使用 '!=' 进行不等比较");
                continue;
            }
            
            // 检查=<（小于等于的错误写法）
            if (strcmp(operator, "=<") == 0) {
                add_lex_error(result, ERR_ILLEGAL_OPERATOR, line, op_start_col,
                            "非法运算符 '=<': C语言中使用 '<=' 进行小于等于比较");
                continue;
            }
            
            // 检查=>（大于等于的错误写法，可能与箭头函数或lambda混淆）
            if (strcmp(operator, "=>") == 0) {
                add_lex_error(result, ERR_ILLEGAL_OPERATOR, line, op_start_col,
                            "非法运算符 '=>': C语言中使用 '>=' 进行大于等于比较");
                continue;
            }
            
            // 检查一般无效运算符
            if (!is_valid) {
                add_lex_error(result, ERR_ILLEGAL_OPERATOR, line, op_start_col,
                            "非法运算符组合 '%s': 不是有效的C语言运算符", operator);
            }
            
            continue;
        }
        
        // 不是运算符，跳过
        ptr++;
        column++;
    }
}

// 主要错误检查函数
static void check_lexical_errors(const char* code, LexResult* result) {
    // 依次调用各个错误检查函数
    
    check_numeric_errors(code, result);
    check_char_string_errors(code, result);
    check_comment_errors(code, result);
    check_invalid_char_errors(code, result);
    check_preprocessor_errors(code, result);
    check_operator_errors(code, result);  // 添加运算符检查
}

// 分析C代码 
LexResult* analyze_c_code(const char* code) {
    // 初始化结果
    LexResult* result = (LexResult*)malloc(sizeof(LexResult));
    if (!result) {
        return NULL;
    }
    
    result->tokens = NULL;
    result->count = 0;
    result->error = NULL;
    result->errors = NULL;
    result->error_count = 0;
    
    // 分配初始token数组
    int capacity = 1024;  // 增大初始容量
    result->tokens = (ShowToken*)malloc(capacity * sizeof(ShowToken));
    if (!result->tokens) {
        free(result);
        return NULL;
    }
    
    // 先进行源代码的预先检查，查找各种词法错误
    check_lexical_errors(code, result);
    // 如果有错误，直接返回结果
    if (result->error_count > 0) {
        return result;
    }
    
    // 初始化词法分析需要的资源
    init_lexer(code);
    next();
    
    while (token) {
        // 获取当前token的文本表示
        const char* token_text = token_buffer;
        
        // 如果token过多，则扩容
        if (result->count >= capacity) {
            capacity *= 2;
            ShowToken* new_tokens = (ShowToken*)realloc(result->tokens, capacity * sizeof(ShowToken));
            if (!new_tokens) {
                result->error = strdup("内存分配失败");
                return result;
            }
            result->tokens = new_tokens;
        }
        
        // 创建新token并添加到结果中
        result->tokens[result->count] = create_token((TokenType)token, token_text, line, column - strlen(token_text));
        
        result->count++;
        
        // 获取下一个token
        next();
    }
    
    return result;
}

// 修改释放词法分析结果函数，处理错误信息
void free_lex_result(LexResult* result) {
    if (!result) return;
    
    if (result->tokens) {
        for (int i = 0; i < result->count; i++) {
            if (result->tokens[i].text) {
                free(result->tokens[i].text);
                result->tokens[i].text = NULL;
            }
        }
        free(result->tokens);
        result->tokens = NULL;
    }
    
    if (result->errors) {
        for (int i = 0; i < result->error_count; i++) {
            if (result->errors[i].message) {
                free(result->errors[i].message);
            }
        }
        free(result->errors);
        result->errors = NULL;
    }
    
    if (result->error) {
        free(result->error);
        result->error = NULL;
    }
    
    free(result);
}

// 修改获取结果的字符串表示
char* get_result_string(LexResult* result) {
    if (!result) return NULL;
    
    if (result->error) {
        return strdup(result->error);
    }
    
    // 估算所需的缓冲区大小，增大容量
    int buffer_size = 16384;  // 16KB
    
    char* buffer = (char*)malloc(buffer_size);
    if (!buffer) return NULL;
    
    int offset = 0;
    
    // 添加标题
    offset += snprintf(buffer + offset, buffer_size - offset, 
                     "词法分析结果：\n"
                     "===================================\n"
                     "%-6s %-12s %-20s %-5s\n"
                     "-----------------------------------\n",
                     "行", "类型", "值", "列");
    
    // 添加每个token
    for (int i = 0; i < result->count && offset < buffer_size - 256; i++) {
        const ShowToken* token = &result->tokens[i];
        const char* type_str = get_token_type_string(token->type);
        const char* text_str = token->text ? token->text : "(null)";
        
        // 确保文本不会太长，超出格式
        char truncated_text[21] = {0};
        if (text_str && strlen(text_str) > 20) {
            strncpy(truncated_text, text_str, 17);
            strcpy(truncated_text + 17, "...");
            text_str = truncated_text;
        }
        
        offset += snprintf(buffer + offset, buffer_size - offset,
                         "%-6d %-12s %-20s %-5d\n",
                         token->line, type_str, text_str, token->column);
    }
    
    
    // 如果结果太大，添加提示
    if (offset >= buffer_size - 256) {
        offset += snprintf(buffer + offset, buffer_size - offset, 
                         "... (结果太大，已截断) ...\n");
    }
    
    return buffer;
}

// 获取错误结果的字符串表示，用于UI界面错误框
char* get_error_string(LexResult* result) {
    if (!result || result->error_count == 0) return NULL;
    
    // 估算所需的缓冲区大小
    int buffer_size = 4096;  // 4KB
    
    char* buffer = (char*)malloc(buffer_size);
    if (!buffer) return NULL;
    
    int offset = 0;
    
    // 添加错误标题
    offset += snprintf(buffer + offset, buffer_size - offset, 
                     "词法分析错误:\n");
                     
    for (int i = 0; i < result->error_count && offset < buffer_size - 256; i++) {
        LexError* error = &result->errors[i];
        offset += snprintf(buffer + offset, buffer_size - offset,
                         "行 %d, 列 %d: %s\n",
                         error->line, error->column, error->message);
    }
    
    // 如果结果太大，添加提示
    if (offset >= buffer_size - 256) {
        offset += snprintf(buffer + offset, buffer_size - offset, 
                         "... (更多错误未显示) ...\n");
    }
    
    return buffer;
}

// 释放get_result_string返回的字符串
void free_result_string(char* str) {
    if (str) {
        free(str);
    }
}

// 测试函数 - 用于独立测试词法分析器
int test_lexer_main(void) {
    // 用于测试的C代码样例，包含多种词法错误
    const char* test_code = 
        "// 测试代码\n"
        " #include <stdio.h> // 预处理指令前有空格\n"
        "int main() {\n"
        "    int 3variable = 10; // 非法标识符\n"
        "    int hex = 0xFG;     // 非法十六进制数字\n"
        "    int oct = 085;      // 非法八进制数字\n"
        "    char c = 'abc';     // 字符常量过长\n"
        "    char c2 = '\\z';    // 非法转义序列\n"
        "    char* str = \"hello; // 未闭合的字符串\n"
        "    /* 未闭合的注释\n"
        "    int while = 5;      // 关键字误用\n"
        "    int x = 3 +* 2;     // 非法运算符\n"
        "    return 0;\n"
        "}\n";
    
    // 调用analyze_c_code函数进行词法分析
    LexResult* result = analyze_c_code(test_code);
    
    // 检查结果
    if (result == NULL) {
        printf("分析失败：analyze_c_code返回NULL\n");
    } else {
        // 获取分析结果字符串
        char* result_str = get_result_string(result);
        if (result_str) {
            printf("%s\n", result_str);
            free_result_string(result_str);
        } else {
            printf("无法获取分析结果字符串\n");
        }
        
        // 测试获取错误字符串功能
        if (result->error_count > 0) {
            printf("\n测试错误输出格式（用于UI错误框）:\n");
            char* error_str = get_error_string(result);
            if (error_str) {
                printf("%s", error_str);
                free_result_string(error_str);
            }
        }
        
        // 打印错误统计
        printf("\n词法错误总数: %d\n", result->error_count);
        
        // 释放结果资源
        free_lex_result(result);
    }
    
    // 释放符号表
    if (symbols) {
        free(symbols);
        symbols = NULL;
    }
    
    printf("分析完成\n");
    return 0;
}

#ifdef LEXER_MAIN
int main(int argc, char** argv) {
    return test_lexer_main();
}
#endif